Metadata-Version: 1.1
Name: Boolean Solver
Version: 0.2.0
Summary: Fast development with generated boolean expressions.
Home-page: https://github.com/jisazaTappsi/BooleanSolver
Author: Juan Pablo Isaza
Author-email: biosolardecolombia@gmail.com
License: MIT
Description: BooleanSolver
        =============
        
        Introduction
        ------------
        
        A picture is worth a thousand words and a vid is worth a thousand
        pictures, so watch a `short intro <https://youtu.be/w8tuJ9kqjJc>`__ or
        continue reading...
        
        This is a `python 2
        project <https://pypi.python.org/pypi/Boolean-Solver>`__ to speed up
        boolean expression coding. Sometimes we need to crack a problem by
        combining boolean operators such as: ``and``, ``or`` & ``not``. We as
        humans are prone to err, specially when expressions get big. But there
        is an algorithm (Quine-McCluskey) to get this expressions with zero
        error. Just specify your specs in a test and set a dummy function on
        your code. When you run your tests a solver will take your specs and
        code them into a simple boolean expression, enjoy :).
        
        Package Setup
        -------------
        
        1. Install Boolean-Solver package: ``$ pip install Boolean-Solver``
        
        Short Example
        -------------
        
        Add new script(start.py) with a mock function:
        
        ::
        
            from boolean_solver import solver as s
        
            @s.solve_boolean()
            def and_function(a, b):
                return False
        
        Add a unittest(test.py) with specs:
        
        ::
        
            import unittest
            from boolean_solver import solver
            import start
        
        
            class MyTest(unittest.TestCase):
                """
                1. Set the truth table of your boolean function (at least for rows where output=True)
                2. run solver.execute(self, callable, table) where callable is the boolean function
                 with the decorator=@solve_boolean() in functions1.
                 See examples below:
                """
                def test_AND_function(self):
        
                #                  b1     b0    output
                truth_table = {((False, False), False),
                               ((False, True), False),
                               ((True, False), False),
                               ((True, True), True)}
        
                solver.execute(self, start.and_function, truth_table)
        
        Then run ``$ python -m unittest test`` and see the result below
        ``def and_function(a, b)``.
        
        Source Code
        -----------
        
        Setup with source code
        ----------------------
        
        1. Clone repository:
           ``$ git clone git@github.com:jisazaTappsi/BooleanSolver.git``
        
        Intro Example with source code
        ------------------------------
        
        1. Enter ``boolean_solver``: ``$ cd boolean_solver/``
        
        2. Run: ``$ python start_sample.py``
        
           ::
        
               Sorry, run:
               $ python -m unittest test_sample
               first, to solve the riddle :)
        
        3. So, run test with: ``$ python -m unittest test_sample``
        
           ::
        
               Solved and tested and_function_3_variables
               .Solved and tested and_function
               .Solved and tested or_function
               .Solved and tested xor_function
               .
               ----------------------------------------------------------------------
               Ran 4 tests in 0.006s
        
               OK
        
        4. Run: ``$ python start_sample.py``
        
           ::
        
                 You made it, Congrats !!!
                 Now, see the functions, enjoy :)
        
        You just solved 4 boolean expressions: ``and``, ``or``, ``xor`` &
        ``and3``. Specs for these functions are in ``test_sample.py``.
        
        How does Boolean Solver works?
        ------------------------------
        
        Takes a function and a truth\_table which is processed using the
        `Quine-McCluskey
        Algorithm <https://en.wikipedia.org/wiki/Quine%E2%80%93McCluskey_algorithm>`__.
        Then finds a optimal boolean expression. This expression is inserted in
        the method definition with the decorator ``@boolean_solver()``.
        
        Arguments of ``solver.execute(test, callable_function, truth_table)``
        ---------------------------------------------------------------------
        
        1. The test case itself, to be able to perform tests, eg: ``self``
        
        2. A function to optimize, passed as a callable (with no arguments).
           This function needs a 3 mock line definition with: line 1: decorator
           = ``@solve_boolean()`` line 2: signature eg: ``def myfunction(a, b)``
           line 3: body: only one line, eg: ``return False``. This line will be
           replaced by the boolean expression.
        
        3. truth table is a set containing tuples. Where each row is a tuple the
           general form is:
        
           ``{tuple_row(tuple_inputs(a, b, ...), output), ...}``
        
Keywords: Quine McCluskey,Boolean,code,automatic code generation,expression,Boolean expression
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 2.7
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development :: Build Tools
